// 版权所有2012 Go作者。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package jpeg

import (
	"image"
)

// makeImg分配并初始化目标映像。
func (d *decoder) makeImg(mxx, myy int) {
	if d.nComp == 1 {
		m := image.NewGray(image.Rect(0, 0, 8*mxx, 8*myy))
		d.img1 = m.SubImage(image.Rect(0, 0, d.width, d.height)).(*image.Gray)
		return
	}

	h0 := d.comp[0].h
	v0 := d.comp[0].v
	hRatio := h0 / d.comp[1].h
	vRatio := v0 / d.comp[1].v
	var subsampleRatio image.YCbCrSubsampleRatio
	switch hRatio<<4 | vRatio {
	case 0x11:
		subsampleRatio = image.YCbCrSubsampleRatio444
	case 0x12:
		subsampleRatio = image.YCbCrSubsampleRatio440
	case 0x21:
		subsampleRatio = image.YCbCrSubsampleRatio422
	case 0x22:
		subsampleRatio = image.YCbCrSubsampleRatio420
	case 0x41:
		subsampleRatio = image.YCbCrSubsampleRatio411
	case 0x42:
		subsampleRatio = image.YCbCrSubsampleRatio410
	default:
		panic("unreachable")
	}
	m := image.NewYCbCr(image.Rect(0, 0, 8*h0*mxx, 8*v0*myy), subsampleRatio)
	d.img3 = m.SubImage(image.Rect(0, 0, d.width, d.height)).(*image.YCbCr)

	if d.nComp == 4 {
		h3, v3 := d.comp[3].h, d.comp[3].v
		d.blackPix = make([]byte, 8*h3*mxx*8*v3*myy)
		d.blackStride = 8 * h3 * mxx
	}
}

// 第B.2.3节规定。
func (d *decoder) processSOS(n int) error {
	if d.nComp == 0 {
		return FormatError("missing SOF marker")
	}
	if n < 6 || 4+2*d.nComp < n || n%2 != 0 {
		return FormatError("SOS has wrong length")
	}
	if err := d.readFull(d.tmp[:n]); err != nil {
		return err
	}
	nComp := int(d.tmp[0])
	if n != 4+2*nComp {
		return FormatError("SOS length inconsistent with number of components")
	}
	var scan [maxComponents]struct {
		compIndex uint8
		td        uint8 // DC表选择器。
		ta        uint8 // AC表格选择器。
	}
	totalHV := 0
	for i := 0; i < nComp; i++ {
		cs := d.tmp[1+2*i] // 组件选择器。
		compIndex := -1
		for j, comp := range d.comp[:d.nComp] {
			if cs == comp.c {
				compIndex = j
			}
		}
		if compIndex < 0 {
			return FormatError("unknown component selector")
		}
		scan[i].compIndex = uint8(compIndex)
		// 第B.2.3节规定“Cs_j的值应不同于
		// Cs_1至Cs_（j-1）的值”。由于我们之前已经验证了帧的组件标识符（第
		// B.2.2节中的C_i值）是唯一的，因此只需检查d.comp中的隐式索引
		// 是唯一的。
		for j := 0; j < i; j++ {
			if scan[i].compIndex == scan[j].compIndex {
				return FormatError("repeated component selector")
			}
		}
		totalHV += d.comp[compIndex].h * d.comp[compIndex].v

		// 表B.3规定了基线t<=1限制。
		scan[i].td = d.tmp[2+2*i] >> 4
		if t := scan[i].td; t > maxTh || (d.baseline && t > 1) {
			return FormatError("bad Td value")
		}
		scan[i].ta = d.tmp[2+2*i] & 0x0f
		if t := scan[i].ta; t > maxTh || (d.baseline && t > 1) {
			return FormatError("bad Ta value")
		}
	}
	// 第B.2.3节规定，如果有多个组件，则扫描中的总H*V值必须小于等于10。
	if d.nComp > 1 && totalHV > 10 {
		return FormatError("total sampling factors too large")
	}

	// zigStart和zigEnd是光谱选择边界。
	// ah和al是逐次逼近的高值和低值。
	// 规范调用这些值Ss、Se、Ah和Al。
	// 
	// 对于渐进JPEG，这是渐进的两个或多或少独立的方面。频谱选择过程是指当一个块的所有64个DCT系数在一个过程中传输时，不是
	// /时。
	// 例如，三次传递可以按Z字形
	// 分量）、系数1-5和系数6-63。逐次逼近是指并非
	// 顺序传输系数0（直流
	// 系数带的所有位都在一次传输中传输。例如，
	// 三次可以传输6个最高有效位，然后是第二个最低有效位，最后是最低
	// 有效位。
	// 
	// 对于顺序JPEG，这些参数硬编码为0/63/0/0，如表B.3所示。
	zigStart, zigEnd, ah, al := int32(0), int32(blockSize-1), uint32(0), uint32(0)
	if d.progressive {
		zigStart = int32(d.tmp[1+2*nComp])
		zigEnd = int32(d.tmp[2+2*nComp])
		ah = uint32(d.tmp[3+2*nComp] >> 4)
		al = uint32(d.tmp[3+2*nComp] & 0x0f)
		if (zigStart == 0 && zigEnd != 0) || zigStart > zigEnd || blockSize <= zigEnd {
			return FormatError("bad spectral selection bounds")
		}
		if zigStart != 0 && nComp != 1 {
			return FormatError("progressive AC coefficients for more than one component")
		}
		if ah != 0 && ah != al+1 {
			return FormatError("bad successive approximation values")
		}
	}

	// mxx和myy是图像中MCU（最小编码单位）的数量。
	h0, v0 := d.comp[0].h, d.comp[0].v // Y分量的h和v值。
	mxx := (d.width + 8*h0 - 1) / (8 * h0)
	myy := (d.height + 8*v0 - 1) / (8 * v0)
	if d.img1 == nil && d.img3 == nil {
		d.makeImg(mxx, myy)
	}
	if d.progressive {
		for i := 0; i < nComp; i++ {
			compIndex := scan[i].compIndex
			if d.progCoeffs[compIndex] == nil {
				d.progCoeffs[compIndex] = make([]block, mxx*myy*d.comp[compIndex].h*d.comp[compIndex].v)
			}
		}
	}

	d.bits = bits{}
	mcu, expectedRST := 0, uint8(rst0Marker)
	var (
		// b是解码后的系数，按自然（非之字形）顺序排列。
		b  block
		dc [maxComponents]int32
		// bx和by是当前块的位置，以8x8为单位
		// 块：第一行的第三个块具有（bx，by）=（2，0）。
		bx, by     int
		blockCount int
	)
	for my := 0; my < myy; my++ {
		for mx := 0; mx < mxx; mx++ {
			for i := 0; i < nComp; i++ {
				compIndex := scan[i].compIndex
				hi := d.comp[compIndex].h
				vi := d.comp[compIndex].v
				for j := 0; j < hi*vi; j++ {
					// 块一次遍历一个MCU。对于4:2:0色度
					// 子采样，每个16x16 MCU中有四个Y 8x8块。
					// 
					// 对于顺序32x16像素图像，Y块访问顺序为：
					// 0 1 4 5 
					// 2 3 6 7 
					// 
					// 对于逐行扫描图像，交错扫描（nComp>1）
					// 如上所述，但非交错扫描是从左到右，从上到下遍历的：
					// 0 1 2 3 
					// 4 5 6 7 
					// 只能交错DC扫描（zigStart==0）。AC扫描必须有
					// 只有一个组件。
					// 
					// 更为复杂的是，对于非交错扫描，MCU级图像内部没有任何块的数据，而像素级图像外部没有任何块的数据。例如，一个24x16像素的4:2:0 
					// 渐进式图像由两个16x16 MCU组成。交错扫描
					// 将处理8个Y块：
					// 0 1 4 5 
					// 2 3 6 7 
					// 非交错扫描将仅处理6个Y块：
					// 0 1 2 
					// 3 4 5 
					if nComp != 1 {
						bx = hi*mx + j%hi
						by = vi*my + j/hi
					} else {
						q := mxx * hi
						bx = blockCount % q
						by = blockCount / q
						blockCount++
						if bx*8 >= d.width || by*8 >= d.height {
							continue
						}
					}

					// 加载先前部分解码的系数，如适用。
					if d.progressive {
						b = d.progCoeffs[compIndex][by*mxx*hi+bx]
					} else {
						b = block{}
					}

					if ah != 0 {
						if err := d.refine(&b, &d.huff[acTable][scan[i].ta], zigStart, zigEnd, 1<<al); err != nil {
							return err
						}
					} else {
						zig := zigStart
						if zig == 0 {
							zig++
							// 根据第F.2.2.1节的规定，对直流系数进行解码。
							value, err := d.decodeHuffman(&d.huff[dcTable][scan[i].td])
							if err != nil {
								return err
							}
							if value > 16 {
								return UnsupportedError("excessive DC component")
							}
							dcDelta, err := d.receiveExtend(value)
							if err != nil {
								return err
							}
							dc[compIndex] += dcDelta
							b[0] = dc[compIndex] << al
						}

						if zig <= zigEnd && d.eobRun > 0 {
							d.eobRun--
						} else {
							// 根据第F.2.2.2节的规定对AC系数进行解码。
							huff := &d.huff[acTable][scan[i].ta]
							for ; zig <= zigEnd; zig++ {
								value, err := d.decodeHuffman(huff)
								if err != nil {
									return err
								}
								val0 := value >> 4
								val1 := value & 0x0f
								if val1 != 0 {
									zig += int32(val0)
									if zig > zigEnd {
										break
									}
									ac, err := d.receiveExtend(val1)
									if err != nil {
										return err
									}
									b[unzig[zig]] = ac << al
								} else {
									if val0 != 0x0f {
										d.eobRun = uint16(1 << val0)
										if val0 != 0 {
											bits, err := d.decodeBits(int32(val0))
											if err != nil {
												return err
											}
											d.eobRun |= uint16(bits)
										}
										d.eobRun--
										break
									}
									zig += 0x0f
								}
							}
						}
					}

					if d.progressive {
						// 保存系数。
						d.progCoeffs[compIndex][by*mxx*hi+bx] = b
						// 此时，我们可以调用ReconstructureBlock去量化并执行
						// 逆DCT，以将渐进图像的早期阶段保存到*image.YCbCr 
						// 缓冲区（渐进编码的整个点），但在Go中，jpeg.Decode 
						// 函数在整个图像解码之前不会返回，因此我们在此处“继续”
						// 以避免浪费计算。相反，在所有
						// 累积块调用ReconstructureBlock
						// 已处理SOS标记。
						continue
					}
					if err := d.reconstructBlock(&b, bx, by, int(compIndex)); err != nil {
						return err
					}
				} // 对于j 
			} // 对于i 
			mcu++
			if d.ri > 0 && mcu%d.ri == 0 && mcu < mxx*myy {
				// 一个更复杂的解码器可以使用RST[0-7]标记从损坏的输入重新同步，
				// 但是这一个假设格式正确的输入，因此重新启动标记立即跟随。
				if err := d.readFull(d.tmp[:2]); err != nil {
					return err
				}

				// 第F.1.2.3节说“标记的字节对齐是通过用1位填充不完整的字节来实现的。如果用1位填充
				// 会产生一个X'FF'值，则在添加标记之前，将填充一个零字节。”
				// 
				// 看到了吗这里的“\xff\x00”不符合规范，因为我们不是
				// 需要一个*不完整*的字节（需要填充）。但是，
				// 一些真实世界的编码器（见golang.org/issue/28717）插入
				// ，因此我们接受它并重新尝试2字节读取。
				// 
				// libjpeg发出警告（但不是错误）为此：
				// https:
				if d.tmp[0] == 0xff && d.tmp[1] == 0x00 {
					if err := d.readFull(d.tmp[:2]); err != nil {
						return err
					}
				}

				if d.tmp[0] != 0xff || d.tmp[1] != expectedRST {
					return FormatError("bad RST marker")
				}
				expectedRST++
				if expectedRST == rst7Marker+1 {
					expectedRST = rst0Marker
				}
				// 重置哈夫曼解码器。
				d.bits = bits{}
				// 根据第F.2.1.3.1节重置DC组件。
				dc = [maxComponents]int32{}
				// 根据第G.1.2.2节重置渐进解码器状态。
				d.eobRun = 0
			}
		} // 对于mx 
	} // 对于我的

	return nil
}

// 优化解码成功e近似求精块，如第G.1.2节所述。第G.1.2节。第
func (d *decoder) refine(b *block, h *huffman, zigStart, zigEnd, delta int32) error {
	// 求精一个直流分量是微不足道的。第
	if zigStart == 0 {
		if zigEnd != 0 {
			panic("unreachable")
		}
		bit, err := d.decodeBit()
		if err != nil {
			return err
		}
		if bit {
			b[0] |= delta
		}
		return nil
	}

	// 求精交流分量更为复杂；见第G.1.2.2节和第G.1.2.3节。第
	zig := zigStart
	if d.eobRun == 0 {
	loop:
		for ; zig <= zigEnd; zig++ {
			z := int32(0)
			value, err := d.decodeHuffman(h)
			if err != nil {
				return err
			}
			val0 := value >> 4
			val1 := value & 0x0f

			switch val1 {
			case 0:
				if val0 != 0x0f {
					d.eobRun = uint16(1 << val0)
					if val0 != 0 {
						bits, err := d.decodeBits(int32(val0))
						if err != nil {
							return err
						}
						d.eobRun |= uint16(bits)
					}
					break loop
				}
			case 1:
				z = delta
				bit, err := d.decodeBit()
				if err != nil {
					return err
				}
				if !bit {
					z = -z
				}
			default:
				return FormatError("unexpected Huffman code")
			}

			zig, err = d.refineNonZeroes(b, zig, zigEnd, int32(val0), delta)
			if err != nil {
				return err
			}
			if zig > zigEnd {
				return FormatError("too many coefficients")
			}
			if z != 0 {
				b[unzig[zig]] = z
			}
		}
	}
	if d.eobRun > 0 {
		d.eobRun--
		if _, err := d.refineNonZeroes(b, zig, zigEnd, -1, delta); err != nil {
			return err
		}
	}
	return nil
}

// 求精非零以之字形顺序求精b的非零项。如果nz>=0，则第
// 跳过第一个nz零项。
func (d *decoder) refineNonZeroes(b *block, zig, zigEnd, nz, delta int32) (int32, error) {
	for ; zig <= zigEnd; zig++ {
		u := unzig[zig]
		if b[u] == 0 {
			if nz == 0 {
				break
			}
			nz--
			continue
		}
		bit, err := d.decodeBit()
		if err != nil {
			return 0, err
		}
		if !bit {
			continue
		}
		if b[u] >= 0 {
			b[u] += delta
		} else {
			b[u] -= delta
		}
	}
	return zig, nil
}

func (d *decoder) reconstructProgressiveImage() error {
	// h0、mxx、by和bx变量的含义与
	// processSOS方法中的含义相同。
	h0 := d.comp[0].h
	mxx := (d.width + 8*h0 - 1) / (8 * h0)
	for i := 0; i < d.nComp; i++ {
		if d.progCoeffs[i] == nil {
			continue
		}
		v := 8 * d.comp[0].v / d.comp[i].v
		h := 8 * d.comp[0].h / d.comp[i].h
		stride := mxx * d.comp[i].h
		for by := 0; by*v < d.height; by++ {
			for bx := 0; bx*h < d.width; bx++ {
				if err := d.reconstructBlock(&d.progCoeffs[i][by*stride+bx], bx, by, i); err != nil {
					return err
				}
			}
		}
	}
	return nil
}

// 重建块去量化，执行逆DCT，并将块
// 存储到图像中。
func (d *decoder) reconstructBlock(b *block, bx, by, compIndex int) error {
	qt := &d.quant[d.comp[compIndex].tq]
	for zig := 0; zig < blockSize; zig++ {
		b[unzig[zig]] *= qt[zig]
	}
	idct(b)
	dst, stride := []byte(nil), 0
	if d.nComp == 1 {
		dst, stride = d.img1.Pix[8*(by*d.img1.Stride+bx):], d.img1.Stride
	} else {
		switch compIndex {
		case 0:
			dst, stride = d.img3.Y[8*(by*d.img3.YStride+bx):], d.img3.YStride
		case 1:
			dst, stride = d.img3.Cb[8*(by*d.img3.CStride+bx):], d.img3.CStride
		case 2:
			dst, stride = d.img3.Cr[8*(by*d.img3.CStride+bx):], d.img3.CStride
		case 3:
			dst, stride = d.blackPix[8*(by*d.blackStride+bx):], d.blackStride
		default:
			return UnsupportedError("too many components")
		}
	}
	// 电平移位+128，剪辑到[0255]，然后写入dst.
	for y := 0; y < 8; y++ {
		y8 := y * 8
		yStride := y * stride
		for x := 0; x < 8; x++ {
			c := b[y8+x]
			if c < -128 {
				c = 0
			} else if c > 127 {
				c = 255
			} else {
				c += 128
			}
			dst[yStride+x] = uint8(c)
		}
	}
	return nil
}
